Micron Document
██████╗ ███████╗████████╗██╗██████╗ ███████╗██████╗ ██╗ █████╗
██╔══██╗██╔════╝╚══██╔══╝██║██╔══██╗██╔════╝██╔══██╗██║██╔══██╗
██████╔╝█████╗ ██║ ██║██████╔╝█████╗ ██║ ██║██║███████║
██╔══██╗██╔══╝ ██║ ██║██╔═══╝ ██╔══╝ ██║ ██║██║██╔══██║
██║ ██║███████╗ ██║ ██║██║ ███████╗██████╔╝██║██║ ██║
╚═╝ ╚═╝╚══════╝ ╚═╝ ╚═╝╚═╝ ╚══════╝╚═════╝ ╚═╝╚═╝ ╚═╝


🬧 The NomadNet Encyclopedia | Archives | Info
- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b

🔍 Search

¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯

Overloading
──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
top
In mwbaprogrammazione, è detta mwbqoverloading (o mwbgsovraccarico) la creazione di una famiglia di mwbwfunzioni/subroutine aventi tutte lo stesso nome, ma che accettino un diverso insieme di argomenti (mwcafirma), e che eventualmente restituiscano un diverso valore di ritorno. Tale famiglia di funzioni è detta mwcqin rapporto di Overloading, o mwcgsovraccaricata. Non tutti i linguaggi di programmazione consentono l'overloading.

A seconda dei casi, si può parlare di overloading di funzioni, di mwdacostruttori e di mwdqoperatori. Sovraccaricare il costruttore di una classe è una pratica comune per gli sviluppatori di mwdglibrerie, in quanto permette loro di fornire allo mwdwsviluppatore finale diverse modalità per istanziare inizializzando l'mweaoggetto della mweqclasse con determinati valori iniziali.

Contents


──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────

Overloading del costruttore e dei metodi delle classi

Ecco alcuni esempi di sovraccarico di un costruttore mwfqPersona e un mwfgmetodo mwfwRubrica.Inserisci, in mwgalinguaggio mwgqVisual Basic (è omessa la dichiarazione di un mwggtipo enumerativo mwgwSesso di valore mwhaMaschio / mwhqFemmina e di alcune implementazioni)

Class Persona
Private _nome As String
Private _cognome As String
Private _nascita As Date
Private _sex As Sesso
Public ReadOnly Property NomeCompleto() As String
Public Sub New(ByVal nome As String, ByVal cognome As String, ByVal nascita As Date, ByVal sex As Sesso)
_nome = nome
_cognome = cognome
_nascita = nascita
_sex = sex
End Sub
Public Sub New(ByVal AltraPersona As Persona)
_nome = altrapersona._nome
_cognome = altrapersona._cognome
_nascita = altrapersona._nascita
_sex = altrapersona._sex
End Sub
End Class
Class Rubrica
[...]
Public Overloads Sub Inserisci(ByVal Nome As String, ByVal Cognome As String)
Public Overloads Sub Inserisci(ByVal Item As Persona)
End Class

In questo modo è possibile inizializzare un'mw9wistanza della classe mw-aPersona sia fornendo nome e cognome come stringa che copiandoli da un'altra istanza di mw-qPersona. Il codice di cui sopra è facilmente riutilizzabile in linguaggi come mw-gC, mw-wC++, mw-aC# e mw-qJava, riscrivendo il tutto secondo la sintassi del linguaggio scelto.

Overloading degli operatori

Prendiamo in considerazione il seguente esempio mwaqaC++: una classe che rappresenta i mwaqenumeri complessi (sono omesse le implementazioni del file mwaqi.cpp)

class Complex
{
private:
double _r;
double _i;
public:
Complex(int r, int i);
Complex(float r, float i);
Complex(double r, double i);
Complex(Complex c);
}

Vorremmo essere in grado di eseguire sui numeri complessi le stesse operazioni che eseguiamo normalmente sui mwavqnumeri reali. Ad esempio, vorremmo poter eseguire il seguente codice:

Complex c,d;
...
if (c < d)
....
...
cout << c;

Tale codice solleverebbe un errore di mwaxicompilazione, in quanto il mwaxmcompilatore non è in grado di valutare da solo se il complesso c è minore di d, né tantomeno di scriverlo a video. La soluzione, adottabile solo in mwaxqC++ e mwaxuC#, è quella di definire un opportuno sovraccarico per gli operatori mwaxy< e mwaxc<<. Per fare ciò è necessario conoscere come il compilatore dei linguaggi C tratta le espressioni con operatore. Esso le traduce con una chiamata a subroutine mwaxgoperator?(), dove al posto di mwaxk? va il simbolo dell'operatore. Ecco quindi i prototipi (e un paio di realizzazioni) di una completa famiglia di overloading per gli operatori principali di confronto e output.

//operator<
int operator<(Complex a, Complex b)
{
return ((a.r*a.r+a.i*a.i)<(b.r*b.r+b.i*b.i));
}
int operator<(Complex a, double b)
{
return ((a.r*a.r+a.i*a.i)<(b*b));
}
int operator<(Complex a, float b);
int operator<(Complex a, int b);
int operator<(double a, Complex b);
int operator<(float a, Complex b);
int operator<(int a, Complex b);
//operator>
int operator>(Complex a, Complex b)
{
return ((a.r*a.r+a.i*a.i)>(b.r*b.r+b.i*b.i));
}
int operator>(Complex a, double b)
{
return ((a.r*a.r+a.i*a.i)>b*b);
}
int operator>(Complex a, float b);
int operator>(Complex a, int b);
int operator>(double a, Complex b);
int operator>(float a, Complex b);
int operator>(int a, Complex b);
//operator<<
ostream& operator<<(ostream& out, Complex c)
{
cout << c.r;
if (c.i > 0)
cout << "+";
cout << c.i << "i";
}

In linguaggio mwaziVisual Basic è possibile simulare il sovraccarico degli operatori implementando l'mwazminterfaccia mwazqIComparable.

Note sull'overloading

Un errore comune di molti programmatori è quello di voler creare due funzioni che accettano gli stessi tipi di parametri in ingresso e restituiscono un tipo differente. Ciò non è possibile perché l'esecutore identifica le mwazcfunzioni e le mwazgsubroutine, a livello mwazkassembly, mediante delle mwazoetichette (mwazslabel). Tali mwazwlabel rispecchiano la mwaz0signature della funzione stessa, e pertanto due mwaz4label uguali non possono coesistere all'interno di uno stesso spazio di visibilità. È comunque possibile definire due o più funzioni dalla stessa mwaz8signature all'interno di mwa0aspazi di nomi diversi senza ottenere errori di compilazione.

L'overloading, infine, non influisce sulla corretta esecuzione delle procedure mwa0iricorsive.

Voci correlate
Collegamenti esterni

• citerefenciclopedia-della-scienza-e-della-tecnicaMauro Cappelli, overloading, in Enciclopedia della scienza e della tecnica, Istituto dell'Enciclopedia Italiana, 2008.
• citereffoldoc(EN) Denis Howe, overloading, in Free On-line Dictionary of Computing. Disponibile con licenza mwa1aGFDL